The field relates generally to computerized control of machines, and more particularly to computerized management of operations performed by components of machines, using multiple threads.
Complex machines, such as those found in a silicon wafer manufacturing plant or other industrial plant, often include multiple components whose operations must be precisely orchestrated to produce a product properly. Often, not only must the multiple components of a given machine work in concert, interactions between different machines must be coordinated as well. The components can include valves, motors, heaters, fans, and sensors, to name a few. To properly make a product pursuant to certain specifications set by an engineer, raw materials might undergo a multitude of processes as they transition into an intermediate product and finally a finished product. The processes might involve, for example, heating silicon in a crucible, extracting the silicon from the crucible at a specific rate and temperature to form a crystal, and partitioning the crystal into wafers. Other processes might include vapor deposition and etching of a wafer of silicon. In other industrial plants, similarly complex processes are carried out.
Rather than relying on human operators to individually control each machine used in processes like those described above, a computerized control server which is communicatively coupled to the components of the various machines monitors the status of each machine and issues instructions to the machine components to generate a product from the raw materials. Often multiple operations on a single machine are being performed concurrently.
Control software for specifying operations can benefit from high-level script engines, which allow instructions to be specified in a manner that does not require an author of a script to address low-level memory and task-switching (e.g., multi-threading) issues. Rather, such issues are typically handled by the script engine automatically. However, script engines typically provide only limited multi-threading capabilities. That is, in typical script engines, multi-threading is implemented at script execution level, where the script engine is explicitly involved in managing script context switches. Moreover, script engines typically suffer from globally-locking garbage collection mechanisms for memory management, thereby blocking further operations until the garbage collection mechanism finishes managing memory. Due to the above-discussed limitations, script engines may not provide sufficient parallelism and deterministic behavior for applications in which predictable timing and parallel execution of instructions is required.